
// pro版promise,增加then的链式调用和catch方法

class MyPromise{
    constructor(executor){
        this.state = 'pending';
        this.value = undefined;
        this.reason = undefined;
        this.onFulfilledCallbacks = [];
        this.onRejectedCallbacks = [];

        const resolve = (value) =>{
            if(this.state === 'pending'){
                this.value = value;
                this.state = 'fulfilled';
                // 执行所有成功回调
                this.onFulfilledCallbacks.forEach(callback => callback());
            }
        }

        const reject = (reason) =>{
            if(this.state === 'pending'){
                this.reason = reason;
                this.state = 'rejected';
                // 执行所有失败回调
                this.onRejectedCallbacks.forEach(callback => callback());
            }
        }

        try{
            executor(resolve,reject);
        }catch(error){
            reject(error)
        }
    }

    
    // 增强then方法，支持链式调用
    then(onfulFilledCallback, onRejectedCallback){
        // 为了支持链式调用，then方法必须返回一个新的Promise
        return new MyPromise((resolve, reject) => { //立即执行函数
            
            // 处理成功回调
            const handleFulfilled = (value) => {
                try {
                    // 如果onfulFilledCallback存在，则执行它
                    if (typeof onfulFilledCallback === 'function') {
                        const result = onfulFilledCallback(value); //将then函数的返回值作为promise的value传给then返回的promise
                        // 如果返回的是Promise，则等待它完成
                        if (result instanceof MyPromise) {
                            result.then(resolve, reject);
                        } else {
                            // 如果返回的是普通值，则直接resolve
                            resolve(result);
                        }
                    } else {
                        // 如果没有提供成功回调，则直接传递值
                        resolve(value);
                    }
                } catch (error) {
                    // 如果回调函数抛出错误，则reject
                    reject(error);
                }
            };

            // 处理失败回调
            const handleRejected = (reason) => {
                try {
                    // 如果onRejectedCallback存在，则执行它
                    if (typeof onRejectedCallback === 'function') {
                        const result = onRejectedCallback(reason);
                        // 如果返回的是Promise，则等待它完成
                        if (result instanceof MyPromise) {
                            result.then(resolve, reject);
                        } else {
                            // 如果返回的是普通值，则resolve（错误被处理了）
                            resolve(result);
                        }
                    } else {
                        // 如果没有提供失败回调，则直接传递错误
                        reject(reason);
                    }
                } catch (error) {
                    // 如果回调函数抛出错误，则reject
                    reject(error);
                }
            };

            // 根据当前状态决定如何处理
            if (this.state === 'fulfilled') {
                // 如果Promise已经完成，立即执行成功回调
                handleFulfilled(this.value);
            } else if (this.state === 'rejected') {
                // 如果Promise已经失败，立即执行失败回调
                handleRejected(this.reason);
            } else if (this.state === 'pending') {
                // 如果Promise还在等待中，将回调添加到队列
                this.onFulfilledCallbacks.push(() => {
                    handleFulfilled(this.value);
                });
                this.onRejectedCallbacks.push(() => {
                    handleRejected(this.reason);
                });
            }
        });
    }

    // 添加catch方法，用于捕获错误
    catch(onRejectedCallback) {
        // catch方法本质上就是then(null, onRejectedCallback)
        return this.then(null, onRejectedCallback);
    }

    // 添加finally方法，无论成功失败都会执行
    finally(onFinallyCallback) {
        return this.then(
            // 成功时执行finally回调，然后返回原值
            (value) => {
                onFinallyCallback();
                return value;
            },
            // 失败时执行finally回调，然后抛出原错误
            (reason) => {
                onFinallyCallback();
                throw reason;
            }
        );
    }

    // 静态方法：Promise.resolve
    static resolve(value) {
        return new MyPromise((resolve) => {
            resolve(value);
        });
    }

    // 静态方法：Promise.reject
    static reject(reason) {
        return new MyPromise((resolve, reject) => {
            reject(reason);
        });
    }
}

// ========== 测试例子：展示增强功能 ==========
console.log('\n=== 测试6：复杂链式调用 ===');
const promise6 = new MyPromise((resolve, reject) => {
    setTimeout(() => {
        resolve(10); 
    }, 100);
});

promise6
    .then(value => {
        console.log('初始值:', value);  //value=10
        return value * 2; // 返回计算后的值
    })
    .then(value => {
        console.log('乘以2后:', value);
        return new MyPromise((resolve) => { // 返回异步Promise
            setTimeout(() => {
                resolve(value + 5);
            }, 200);
        });
    })
    .then(value => {
        console.log('加5后:', value);
        if (value > 20) {
            throw new Error('数值太大'); // 条件性抛出错误
        }
        return value * 3;
    })
    .then(value => {
        console.log('乘以3后:', value);
    })
    .catch(error => {
        console.log('捕获到错误:', error.message);
        return 0; // 错误恢复
    })
    .finally(() => {
        console.log('计算完成');
    });

console.log('\n=== 测试完成 ===');
